home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DClap / DApplication.cpp < prev    next >
Text File  |  1996-07-05  |  33KB  |  1,354 lines
  1. // DApplication.cp
  2.  
  3.  
  4. #include "DClap.h"
  5. #include "DFindDlog.h"
  6.  
  7.  
  8. #if 0
  9. // Skeleton for application is
  10.  
  11. extern "C" Int2 Main (void)
  12. {
  13.   DMyApplication* myapp = new DMyApplication();
  14.   myapp->IApplication("App Name");
  15.   myapp->Run();
  16.   return 0;
  17. }
  18.  
  19. #endif
  20.  
  21.  
  22. DApplication* gApplication = NULL;        // the current application object
  23.  
  24. char* DApplication::kName=  NULL;
  25. char* DApplication::kVersion= NULL;
  26. char* DApplication::kHelpfolder = "Help";
  27. Nlm_RecT DApplication::fgAppWinRect;
  28.  
  29. extern "C" Nlm_Char        gProgramName[PATH_MAX];// from vibwndws.c
  30.  
  31.                     
  32. class DNoteWindow : public DWindow 
  33. {
  34. public:    
  35.     DNoteWindow(const char* message) :
  36.         DWindow( 0, NULL, DWindow::fixed, -5, -5, -50, -20, NULL)
  37.     {    
  38.     DNotePanel* note= new DNotePanel(0, this, message, 0, 0, Nlm_systemFont, justcenter);
  39.     }
  40.  
  41. };
  42.  
  43.  
  44.  
  45.  
  46.  
  47. class DWindowChoiceDialog : public DWindow 
  48. {
  49. public:
  50.     DListBox * fListBox;
  51.     short             fChoice;
  52.     DList      * fList;
  53.     
  54.     DWindowChoiceDialog();
  55.     void Open();
  56.     void OkayAction();
  57.     DWindow* Result();
  58. };
  59.  
  60.  
  61. DWindowChoiceDialog::DWindowChoiceDialog() :
  62.         DWindow( 0, NULL, DWindow::fixed, -10, -10, -50, -20, "Window list", kDontFreeOnClose),
  63.         fChoice(-1),
  64.         fList(NULL),
  65.         fListBox(NULL)
  66. {    
  67.     fList= gWindowManager->GetWindowList();
  68. }
  69.  
  70. void DWindowChoiceDialog::Open()
  71. {
  72.         // NOTE: this window is in window list !!
  73.     DPrompt* pr= new DPrompt(0, this, "Select a window");         
  74.     DListBox* lb= new DListBox(0, this, 20, 5, false);
  75.     fListBox= lb;
  76.     lb->SetResize( DView::relsuper, DView::relsuper);
  77.     lb->StartAppending();
  78.             
  79.     if (fList) {
  80.         char    title[256];
  81.         long i, n= fList->GetSize();
  82.         for (i= n-1; i>=0; i--) {
  83.             DWindow* win= (DWindow*) fList->At(i);
  84.             if (win != this) 
  85.             {
  86.                 win->GetTitle(title,256);
  87.                 lb->Append( title);
  88.                 }
  89.             }
  90.          }
  91.     lb->DoneAppending();
  92.     lb->SetValue(1); // doesn't seem active on DListBox display
  93.     
  94.     this->AddOkayCancelButtons();    
  95.     DWindow::Open();
  96. }
  97.  
  98. void DWindowChoiceDialog::OkayAction() 
  99. { 
  100.     //fChoice= fListBox->GetValue() - 1;  
  101.         //min GetValue==1, win fChoices == 0..GetSize-2, skip topwin = this
  102.     fChoice= (fList->GetSize() - 1) - (fListBox->GetValue() - 1);   
  103. }
  104.     
  105. DWindow* DWindowChoiceDialog::Result() 
  106. { 
  107.     if (fChoice<0) return NULL;
  108.     else return (DWindow*) fList->At(fChoice); 
  109. }
  110.     
  111.  
  112. // CLASS DAppWin
  113. class DAppWin : public DWindow
  114. {
  115. public:
  116.     DAppWin(long id, DTaskMaster* itsSuperior, WindowStyles style,
  117.                     short width = -5, short height = -5, short left = -50, short top = -20, 
  118.                     char* title = NULL, Nlm_Boolean freeOnClose= kFreeOnClose)
  119.         : DWindow( id, itsSuperior, style, width, height, left, top,
  120.                         title, freeOnClose)
  121.     { }
  122.     virtual void MakeGlobalsCurrent();
  123.     virtual void Close();
  124.     virtual void ResizeWin();
  125. };
  126.  
  127. void DAppWin::MakeGlobalsCurrent()
  128. {
  129.     ViewRect( fViewrect);  
  130.     if (!Nlm_EmptyRect(&fViewrect)) DApplication::fgAppWinRect= fViewrect;  
  131. }
  132.  
  133. void DAppWin::Close()
  134. {
  135.     MakeGlobalsCurrent();
  136.     DWindow::Close();
  137. }
  138.  
  139. void DAppWin::ResizeWin()
  140. {
  141.     DWindow::ResizeWin();
  142.     MakeGlobalsCurrent();
  143. }
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150. // CLASS DApplication
  151.  
  152. DApplication::DApplication() :
  153.     DTaskMaster(cAppl)
  154. {
  155.     fDone= false;    
  156.     fDidOpenStartDoc= false;    
  157.     fAppID= NULL;
  158.     fAppWindow= NULL;  
  159.     fPathname= NULL;
  160.     fShortname= NULL;
  161.     fAboutLine= NULL;
  162.     fFileSuffix= NULL;
  163.     fAcceptableFileTypes= NULL;
  164.     gApplication= this;
  165.         // default file types
  166.     fFileSuffix = ".txt";
  167.     fAcceptableFileTypes= "TEXT";
  168. }
  169.  
  170.  
  171.  
  172. void DApplication::IApplication(const char* theAppName)
  173. {
  174.     //xdebug("DApplication::IApplication");
  175.     DClapGlobals* initglobals = new DClapGlobals();
  176.     gCursor->watch();  
  177.     
  178.     if (kName) StrNCpy( gProgramName, kName, PATH_MAX); // for vibwndws.c
  179.     fPathname = StrDup( gFileManager->GetProgramPath());
  180.     if (theAppName) 
  181.         fShortname= StrDup( theAppName);
  182.     else if (kName) 
  183.         fShortname= StrDup( kName);
  184.     else {
  185.         fShortname= StrDup( gFileManager->FilenameFromPath(fPathname));   
  186.         char * suf= (char*)gFileManager->FileSuffix(fShortname);
  187.         if (suf) *suf= 0; // we don't want no steenking suffix here
  188.         }
  189.         
  190.     char buf[512];
  191.     sprintf( buf, "About %s...", Shortname()); 
  192.     fAboutLine= StrDup(buf);
  193.      
  194.     char *tid= DFileManager::TempFilenameonly();
  195.     if (StrNCmp(tid, "tmp", 3)) tid += 2;
  196.     fAppID= StrDup(tid);
  197.     //fAppID[0]= 'D'; //??
  198.     
  199. #ifndef WIN_MAC
  200.     if (!fAppWindow) {
  201.             // Non-Mac apps need an fAppWindow to put any application menus into 
  202.             // eventually want user pref for main wind rect...
  203.     short width= 450, height = 60;
  204.       Nlm_LoadRect( &fgAppWinRect, 0, 0, width, height);
  205.       char* srect = gApplication->GetPref( "fgAppWinRect", "windows", "0 0 450 60");
  206.         if (srect) {
  207.             sscanf( srect, "%hd%hd%hd%hd", &fgAppWinRect.left, &fgAppWinRect.top, 
  208.                                                 &fgAppWinRect.right, &fgAppWinRect.bottom);
  209.             width = MAX( 40, fgAppWinRect.right - fgAppWinRect.left); 
  210.             height= MAX( 60, fgAppWinRect.bottom - fgAppWinRect.top);   
  211.             MemFree(srect);
  212.             }
  213.         fAppWindow= new DAppWin(cAppW, this, DWindow::document, 
  214.                 width, height, fgAppWinRect.left, fgAppWinRect.top, 
  215.                 (char*)Shortname());
  216.         gWindowManager->SetAppWindow(fAppWindow);
  217.         //fAppWindow->Open(); //<<bad here -- main event loop
  218.         }
  219. #endif
  220.     
  221.     if (!gIconList) gIconList = new DIconList(); //<< do in DIconList.cpp as global init.
  222.   gIconList->ReadAppIcons();
  223.  
  224.     this->InitSpecialEvents();
  225.     this->InstallDefaultPrefs(); // do before calling any GetPref, after ShortName set
  226.     DFindDialog::InitFindDialog();
  227.     
  228.         // read some user prefs
  229.     gTextFontName= this->GetPref( "gTextFontName", "fonts", gTextFontName);
  230.     gTextFontSize= this->GetPrefVal( "gTextFontSize", "fonts", "12");
  231.     gTextTabStops= this->GetPrefVal( "gTextTabStops", "fonts", "4");
  232.     gTextFont         = Nlm_GetFont( gTextFontName, gTextFontSize, false, false, false, NULL);
  233.     if (!gTextFont) gTextFont= Nlm_programFont;
  234.     gItalicTextFont= Nlm_GetFont( gTextFontName, gTextFontSize, false, true, false, NULL);
  235.     if (!gItalicTextFont) gItalicTextFont= Nlm_programFont;
  236.     gBoldTextFont= Nlm_GetFont( gTextFontName, gTextFontSize, true, false, false, NULL);
  237.     if (!gBoldTextFont) gBoldTextFont= Nlm_programFont;
  238.     gUlineTextFont= Nlm_GetFont( gTextFontName, gTextFontSize, false, false, true, NULL);
  239.     if (!gUlineTextFont) gUlineTextFont= Nlm_programFont;
  240.   
  241.     DCluster::SetFont(Nlm_programFont);  
  242.  
  243.     this->SetUpMenus();
  244.     this->UpdateMenus(); // !! need to have this called in task loop somewhere !!
  245.     
  246.     //if (gOpenStartDocs) 
  247.     //OpenStartDocs();
  248. } 
  249.  
  250.  
  251. DApplication::~DApplication()
  252. {
  253.     if (gIconList) gIconList->suicide();
  254.     if (fAboutLine) MemFree( fAboutLine);
  255.     if (fShortname) MemFree( fShortname);
  256.     if (fPathname) MemFree( fPathname);
  257.     gApplication= NULL;
  258. }  
  259.  
  260.  
  261.  
  262. const char*    DApplication::Pathname(void)
  263. {
  264.     return    fPathname;
  265. }
  266.  
  267. const char*    DApplication::Shortname(void)
  268. {
  269.     static char buf[256];
  270.     StrNCpy(buf, fShortname, 256); // having problems w/ someone mangling this string !
  271.     return buf;
  272. }
  273.  
  274.  
  275.  
  276.  
  277. #ifdef WIN_MAC
  278. #ifndef __APPLEEVENTS__
  279.     // undef some conflicts b/n Types.h && NlmTypes
  280. #undef Handle
  281. #include <AppleEvents.h>
  282. #include <Strings.h>
  283. #endif
  284.  
  285. // ?!? 68k mac calls to here now fail --  
  286. // !! REQUIRES 'pascal' function call settings for Mac68K callbacks !
  287. #define CALLBACKFORM pascal
  288. //#define CALLBACKFORM extern "C"
  289.  
  290. #else
  291. #define CALLBACKFORM
  292. #endif
  293.  
  294. #ifdef WIN_MOTIF
  295.  
  296. #ifdef OS_UNIX_OSF1
  297. #undef _OSF_SOURCE
  298. #undef _POSIX_4SOURCE
  299. #define _ANSI_C_SOURCE
  300. #endif
  301.  
  302. #include <signal.h>
  303. #if defined(OS_UNIX_SUN) || defined(OS_UNIX_IRIX) || defined(OS_UNIX_LINUX)
  304. #include <sys/wait.h>
  305. #else
  306. #include <wait.h>
  307. #endif
  308.  
  309. extern int           statargc;
  310. extern char          **statargv;
  311. #endif
  312.  
  313.  
  314. // === AppleEvent Numbers ===
  315.  
  316. enum {
  317.                                         // Required Suite
  318. ae_OpenApp            = 1001,
  319. ae_OpenDoc            = 1002,
  320. ae_PrintDoc            = 1003,
  321. ae_Quit                = 1004,
  322.  
  323.                                         // Core Suite
  324. ae_Clone            = 2001,
  325. ae_Close            = 2002,
  326. ae_CountElements    = 2003,
  327. ae_CreateElement    = 2004,
  328. ae_Delete            = 2005,
  329. ae_DoObjectsExist    = 2006,
  330. ae_GetClassInfo        = 2007,
  331. ae_GetData            = 2008,
  332. ae_GetDataSize        = 2009,
  333. ae_GetEventInfo        = 2010,
  334. ae_Move                = 2011,
  335. ae_Open                = 1002,        // Same as ae_OpenDoc
  336. ae_Print            = 1003,        // Same as ae_PrintDoc
  337. ae_Save                = 2012,
  338. ae_SetData            = 2013,
  339.                                         // Miscellaneous Standards
  340. ae_ApplicationDied    = 3001,
  341. ae_BeginTransaction    = 3002,
  342. ae_Copy                = 3003,
  343. ae_CreatePublisher    = 3004,
  344. ae_Cut                = 3005,
  345. ae_DoScript            = 3006,
  346. ae_EditGraphic        = 3007,
  347. ae_EndTransaction    = 3008,
  348. ae_ImageGraphic        = 3009,
  349. ae_IsUniform        = 3010,
  350. ae_MakeObjVisible    = 3011,
  351. ae_Paste            = 3012,
  352. ae_Redo                = 3013,
  353. ae_Revert            = 3014,
  354. ae_TransactionTerm    = 3015,
  355. ae_Undo                = 3016,
  356. ae_Select            = 3017
  357. };
  358.  
  359.  
  360.  
  361. #ifdef WIN_MAC
  362.  
  363. static AEDescList    gAEDocList;
  364. static long gAEndoc, gAEidoc;
  365.  
  366. static Boolean SetAFileEvent( long inEvent, long outReply)
  367. {                    
  368.     AppleEvent    *aeEvent, *aeReply;
  369.     short                err;
  370.     
  371.     gAEndoc = gAEidoc = 0;
  372.     if (!inEvent) return false;
  373.     aeEvent = (AppleEvent*) inEvent;
  374.     //aeReply = (AppleEvent*) outReply;
  375.     err= AEGetParamDesc( aeEvent, keyDirectObject, typeAEList, &gAEDocList);
  376.     if (err) return false;
  377.     err= AECountItems( &gAEDocList, &gAEndoc);
  378.     return (err == 0);
  379. }
  380.  
  381. static void ClearAFileEvent()
  382. {                    
  383.     if (gAEndoc) {
  384.         (void) AEDisposeDesc( &gAEDocList);
  385.         gAEndoc= 0;
  386.         }
  387. }
  388.  
  389. static const char* GetNextAEFile()
  390. {                    
  391.     short                err;
  392.     AEKeyword        keywd;
  393.     DescType        returnedType;
  394.     FSSpec            aFileSpec;
  395.     Size                actualSize;
  396.     
  397.     if (gAEidoc < gAEndoc) {
  398.         gAEidoc++;
  399.         err= AEGetNthPtr( &gAEDocList, gAEidoc, typeFSS, &keywd, &returnedType,
  400.                                             (void*)&aFileSpec, sizeof(aFileSpec), &actualSize);
  401.         if (err) return NULL; 
  402. #ifdef COMP_THINKC
  403.         PtoCstr ((StringPtr) aFileSpec.name);
  404. #else
  405.         p2cstr((StringPtr) aFileSpec.name);
  406. #endif
  407.         return MacDirIDtoName( aFileSpec.vRefNum, aFileSpec.parID,
  408.                                                          (char*) aFileSpec.name);
  409.         }
  410.     else
  411.         return NULL;
  412. }
  413. #endif
  414.  
  415.  
  416. static Boolean gDidOpenStartDoc = false;
  417.  
  418. static void HandleFileEvent(long inEvent, long outReply, short tasknum)
  419. {
  420. #ifdef WIN_MAC
  421.     if (::SetAFileEvent( inEvent, outReply)) {
  422.         const char* path;
  423.         do {
  424.             path= ::GetNextAEFile();
  425.             if (path) {
  426.                 //gApplication->OpenDocument( (char*) path);
  427.                 DTask* filetask= 
  428.                   gApplication->newTask( tasknum, DTask::kMenu, (long)path);
  429.                 gApplication->DoMenuTask( tasknum, filetask);
  430.                 delete filetask;
  431.                 gApplication->fDidOpenStartDoc= true;
  432.                 }
  433.         } while (path);
  434.         ::ClearAFileEvent();
  435.         }
  436. #endif
  437.  
  438. #ifdef WIN_MOTIF
  439.     if (statargc > 1 
  440.    && !gDidOpenStartDoc) { 
  441.   //! gApplication->fDidOpenStartDoc) 
  442.         const char* path;
  443.         for (long i=1; i<statargc; i++) {
  444.             path= statargv[i];
  445.             if (path) {
  446.                 //gApplication->OpenDocument( (char*) path);
  447.                 DTask* filetask= 
  448.                   gApplication->newTask( tasknum, DTask::kMenu, (long)path);
  449.                 gApplication->DoMenuTask( tasknum, filetask);
  450.                 delete filetask;
  451.                 gApplication->fDidOpenStartDoc= true;
  452.                 }
  453.             } 
  454.         }
  455. #endif
  456. }
  457.  
  458.  
  459.  
  460. Boolean  DApplication::GotStartDocs()
  461. {
  462.     return fDidOpenStartDoc;
  463. }
  464.  
  465. Boolean DApplication::OpenStartDocs()
  466. {
  467.     gDidOpenStartDoc= fDidOpenStartDoc;
  468.     HandleSpecialEvent( 0, 0, ae_OpenDoc);
  469.     return fDidOpenStartDoc;
  470. }
  471.  
  472. #ifdef COMP_CWI
  473. static short int HandleSpecialEvent( long inEvent, long outReply, long inNumber)
  474. #else
  475. CALLBACKFORM short HandleSpecialEvent( long inEvent, long outReply, long inNumber)
  476. #endif
  477. {
  478.     short tasknum;
  479.     
  480.     switch (inNumber) {
  481.     
  482.         case ae_ApplicationDied:
  483.             (void) DChildAppManager::BuryDeadChildApp( inEvent);
  484.             break;
  485.             
  486.         case ae_Quit:
  487.             gApplication->Quit();
  488.             break;
  489.  
  490.         case ae_OpenApp:
  491.             //StartUp();
  492.             break;
  493.             
  494.         case ae_PrintDoc:
  495.             tasknum= DApplication::kPrintAFile;
  496.             goto caseOpenDoc;
  497.  
  498.         case ae_OpenDoc:
  499.             tasknum= DApplication::kOpenAFile;
  500.         caseOpenDoc:        
  501.             ::HandleFileEvent(inEvent, outReply, tasknum);
  502.             break;
  503.             
  504.         case ae_Copy:
  505.         case ae_Cut:
  506.         case ae_Paste:
  507.         case ae_Redo:
  508.         case ae_Undo:
  509.         default:
  510.             //DSomeone::HandleAppleEvent( inAppleEvent, outAEReply, outResult, inNumber);
  511.             break;
  512.         }
  513.  
  514.     return 0;
  515. }
  516.  
  517.  
  518. #ifdef WIN_MAC
  519. CALLBACKFORM short HandleChildDiedEvent( long inEvent, long outReply, long inNumber)
  520. {
  521.     return ::HandleSpecialEvent( inEvent, outReply, ae_ApplicationDied);
  522. }
  523. #endif
  524.  
  525. #ifdef WIN_MOTIF
  526. static void HandleChildDiedEvent(int signo)
  527. {
  528.     long     pid;
  529.     int        status;
  530.     //pid= wait( &status);
  531.     do {
  532.          pid= waitpid(-1, &status, WNOHANG|WUNTRACED);
  533.          // note: if child exits w/ error, exit(!0), pid == -1 !
  534.         if (pid>0) ::HandleSpecialEvent( pid, 0, ae_ApplicationDied); 
  535.     } while (pid>0);
  536. }
  537. #endif
  538.  
  539.  
  540. short DApplication::HandleSpecialEvent( long inEvent, long outReply, long inNumber)
  541. {
  542.     return ::HandleSpecialEvent(inEvent, outReply, inNumber);
  543. }
  544.  
  545.  
  546. void DApplication::InitSpecialEvents()
  547. {
  548.     short err;
  549. #ifdef WIN_MAC
  550.  
  551.     // problems w/ "aevt-oapp" call bombing on 68k mac but not ppc mac
  552.     
  553. #define aeproccall(x) NewAEEventHandlerProc(x)
  554. //#define aeproccall(x) ((AEEventHandlerUPP)(x))
  555.  
  556.     err= ::AEInstallEventHandler( kCoreEventClass, kAEOpenApplication,
  557.                                 aeproccall(::HandleSpecialEvent), 
  558.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  559.                                 ae_OpenApp, false);
  560.     err= ::AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, 
  561.                                 aeproccall(::HandleSpecialEvent), 
  562.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  563.                                 ae_Quit, false);
  564.  
  565.     err= ::AEInstallEventHandler( kCoreEventClass, kAEApplicationDied, 
  566.                                 aeproccall(::HandleChildDiedEvent), 
  567.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  568.                                 ae_ApplicationDied, false);
  569.                                 
  570.     err = ::AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
  571.                                 aeproccall(::HandleSpecialEvent), 
  572.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  573.                                 ae_OpenDoc, false);
  574.     err = ::AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments,
  575.                                 aeproccall(::HandleSpecialEvent), 
  576.                                 //aeproccall(DApplication::HandleSpecialEvent), 
  577.                                 ae_PrintDoc, false);
  578.  
  579. #endif
  580.  
  581. #ifdef WIN_MOTIF
  582.     // install signals to trap ?? childDied events at least
  583.     //err= sighold( SIGCHLD);
  584. #ifndef OS_UNIX_IRIX
  585.         // need to figure out IRIX format for this
  586.      signal( SIGCHLD, HandleChildDiedEvent); 
  587. #endif
  588. #endif
  589. }
  590.  
  591.  
  592.  
  593. Boolean DApplication::InstallDefaultPrefs(const char* defaultSuffix, const char* appName)
  594. {
  595.     Boolean foundprefs, didinstall= false;
  596.     char  *cp, defaultPrefs[512];
  597.     
  598.         // locate any program default preference file
  599.     if (!appName) appName= Shortname();
  600.  
  601.     StrNCpy(defaultPrefs, (char*)appName, 512);
  602.     cp= (char*)gFileManager->FileSuffix(defaultPrefs); if (cp) *cp= 0;
  603.     StrNCat(defaultPrefs, (char*)defaultSuffix, 512);
  604.     foundprefs= gFileManager->FileExists(defaultPrefs);
  605.     if (!foundprefs) {
  606.         const char* appPath = gFileManager->GetProgramPath();  
  607.         appPath= gFileManager->PathOnlyFromPath( appPath);
  608.         StrNCpy(defaultPrefs, (char*)appPath, 512);
  609.         StrNCat(defaultPrefs, (char*)appName, 512);
  610.         cp= (char*)gFileManager->FileSuffix(defaultPrefs); if (cp) *cp= 0;
  611.         StrNCat(defaultPrefs, (char*)defaultSuffix, 512);
  612.         foundprefs= gFileManager->FileExists(defaultPrefs);
  613.         }
  614.     
  615.     if (foundprefs) {
  616.         short     iline, nlines = 0;
  617.         char    **linelist;
  618.         char    * cp, * line = NULL, * section = NULL, * varname = NULL, * params = NULL;
  619.         long         curver= 0, defver= 0;
  620.          
  621.         curver= this->GetPrefVal("version","general",NULL);
  622.         linelist= gPrefManager->GetPrefFileLines( defaultPrefs, nlines);
  623.  
  624.             // 1st check quickly if defaultPrefs has anything newer than user prefs
  625.             // if not, exit silently, else put up notice window....
  626.         for (iline= 0; iline<nlines; iline++) {
  627.             line= linelist[iline];
  628.             if (*line == '[') { // sect name 
  629.                 cp= StrStr(line,"[version=");
  630.                 if (cp) defver= atol(cp+9);
  631.                 if (defver > curver) break;
  632.                 }
  633.             }
  634.         if (defver <= curver) {
  635.             for (iline= 0; iline<nlines; iline++) {
  636.                 line= linelist[iline];
  637.                 MemFree(line);
  638.                 }
  639.             MemFree(linelist);
  640.             return false;    
  641.             }
  642.             
  643.         Nlm_MonitorPtr progress= Nlm_MonitorIntNew("Installing new preferences...", 0, nlines);
  644.                 // ^^^ incorporate Nlm_Monitor into a DCLAP class
  645.         gCursor->watch();
  646.         for (iline= 0; iline<nlines; iline++) {
  647.             if (Nlm_MonitorIntValue(progress, iline)) ;
  648.             line= linelist[iline];
  649.             if (line) {
  650.                 if (*line == '[') { // sect name 
  651.                     cp= StrStr(line,"[version=");
  652.                     if (cp)  
  653.                         defver= atol(cp+9);
  654.                     else {
  655.                         if (section) MemFree(section);
  656.                         section= StrDup(line+1);
  657.                         }
  658.                     }
  659.                 else {
  660.                     params= StrChr(line, '=');
  661.                     if (params) { *params++= 0; if (!*params) params= NULL; }
  662.                     varname= line;
  663.                     if (defver > curver) {
  664.                         this->SetPref( params, varname, section);
  665.                         }
  666.                     }
  667.                 MemFree(line);
  668.                 }
  669.             }
  670.         MemFree(linelist);
  671.         this->SetPref(defver, "version","general");
  672.         didinstall= true;
  673.         Nlm_MonitorFree(progress);        
  674.         }
  675.      return didinstall;
  676. }
  677.  
  678.  
  679.  
  680.  
  681. char*    DApplication::GetPref(char* type, char* section, char* defaultvalue)
  682. {
  683.     return gPrefManager->GetAppPref( type, section, (char*)Shortname(), defaultvalue);
  684. }
  685.  
  686. long    DApplication::GetPrefVal(char* type, char* section, char* defaultvalue)
  687. {
  688.     long val= 0;
  689.     char* sval= gPrefManager->GetAppPref( type, section, (char*)Shortname(), defaultvalue);
  690.     if (sval) {
  691.         val= atol(sval);
  692.         MemFree(sval);
  693.         }
  694.     return val;
  695. }
  696.  
  697. char*    DApplication::GetPrefSection(char* section, ulong& sectlen, char* defaultvalue)
  698. {
  699.     return gPrefManager->GetAppPrefSection(section, sectlen, (char*)Shortname(), defaultvalue);
  700. }
  701.  
  702.  
  703. Boolean DApplication::SetPref(char* prefvalue, char* type, char* section)
  704. {
  705.     return gPrefManager->SetAppPref(prefvalue, type, section, (char*)Shortname());
  706. }
  707.  
  708. Boolean DApplication::SetPref(long prefvalue, char* type, char* section)
  709. {
  710.     char    snum[256];
  711.     sprintf(snum, "%d", prefvalue);
  712.     return gPrefManager->SetAppPref(snum, type, section, (char*)Shortname());
  713. }
  714.  
  715.  
  716. char*    DApplication::ConvertStdFilePath(char* pathname)
  717. {
  718.     char     *path, *atcolon, *name, *newpath;
  719.     
  720.     pathname= StrDup( pathname);
  721.     atcolon= StrChr(pathname, ':');
  722.     if (atcolon) {
  723.         name= atcolon+1;
  724.         *atcolon= 0;
  725.         path= this->GetPref( pathname, "paths", NULL);
  726.             // GetPref always returns nonNULL path
  727.         if (path && *path != '\0') {
  728. defaultpath:
  729.             DFileManager::UnixToLocalPath(path);
  730.             if (DFileManager::IsRelativePath(path)) {
  731.                 const char* appPath= DFileManager::PathOnlyFromPath( fPathname);
  732.                 newpath= StrDup( DFileManager::BuildPath( appPath, path, name)); 
  733.                 }
  734.             else
  735.                 newpath= StrDup( DFileManager::BuildPath( path, NULL, name)); 
  736.             MemFree( pathname);
  737.             MemFree( path);
  738.             pathname= newpath;
  739.             }
  740.         else if (StrICmp( pathname, "temp")==0) {
  741.             path= DFileManager::TempFolder();
  742.             newpath= StrDup( DFileManager::BuildPath( path, NULL, name)); 
  743.             MemFree( pathname);
  744.             pathname= newpath;
  745.             }
  746. #ifdef WIN_MAC
  747.         else {
  748.             *atcolon= ':';
  749.             }
  750. #else
  751.         else if (path)
  752.             goto defaultpath;
  753.         else {
  754.             // return full pathname !?
  755.             // MemMove(pathname, name, StrLen(name)+1);
  756.             }
  757. #endif
  758.         }
  759.     return pathname;
  760. }
  761.  
  762. char*    DApplication::GetFilePref(char* type, char* section, char* defaultvalue)
  763. {
  764.     char * pathname, *newpath;
  765.  
  766.     pathname = this->GetPref( type, section, defaultvalue);
  767.     newpath = ConvertStdFilePath( pathname);
  768.     MemFree( pathname);
  769.     return newpath;
  770. }
  771.  
  772.  
  773.  
  774.  
  775.  
  776.  
  777. #ifdef WIN_MOTIF
  778. extern void TaskCentralIdleEvent()
  779. {
  780.     gTaskCentral->NextTask();
  781. }
  782. #endif
  783.  
  784. void    DApplication::Run(void)
  785. {
  786.     if (fAppWindow)  fAppWindow->Open();
  787.     if (gClipboardMgr) gClipboardMgr->Launch();     
  788.  
  789.     gCursor->arrow();  
  790. #ifdef WIN_MOTIF
  791.   Nlm_Metronome( TaskCentralIdleEvent);
  792. #endif
  793.     this->MainEventLoop();
  794.     gCursor->arrow();
  795. }
  796.  
  797. void DApplication::MainEventLoop(void)
  798. {
  799.     while (!fDone) this->ProcessTasks();
  800. }
  801.  
  802. void DApplication::ProcessTasks(void)
  803. {
  804.     Nlm_ProcessEventOrIdle();
  805.     Nlm_RemoveDyingWindows();
  806.     gTaskCentral->NextTask();
  807. }
  808.  
  809. Boolean    DApplication::EventsAvail() 
  810. { 
  811.     return Nlm_EventAvail();
  812. }
  813.  
  814. void    DApplication::FlushEvents() 
  815. { 
  816.     Nlm_FlushEvents();
  817. }
  818.  
  819.  
  820. void DApplication::Quit()
  821. {
  822.     fDone= true;
  823.     if (gWindowManager) delete gWindowManager; gWindowManager= NULL;
  824.     // ?? ^^ is this okay, we got one bomb on a DWindow call after Quit & WinMgr == NULL
  825.  
  826.     if (!Nlm_EmptyRect(&fgAppWinRect)) {
  827.         char  srect[128];
  828.         sprintf( srect, "%d %d %d %d", fgAppWinRect.left, fgAppWinRect.top, 
  829.                                                         fgAppWinRect.right, fgAppWinRect.bottom);
  830.         gApplication->SetPref( srect, "fgAppWinRect", "windows");
  831.         }
  832.  
  833.   Nlm_QuitProgram (); // this justs sets a local vibrant global, in ProcessEvents(), which we don't see
  834. }
  835.  
  836. void    DApplication::SetAppMenuWindow(DWindow* itsWindow)
  837. {
  838.     fAppWindow= itsWindow;
  839. }
  840.  
  841.  
  842. void    DApplication::OpenDocument(char* pathname)
  843. {
  844.     DFile *afile= new DFile( pathname, "r");
  845.     OpenDocument( afile);
  846.     delete afile; // ???
  847. }
  848.  
  849. void    DApplication::OpenDocument(DFile* aFile)
  850. {
  851.     // default OpenDoc is to use Vibrant's text display
  852.     if (aFile && aFile->Exists()) {
  853.         Nlm_ParData  paratabs = {false, false, false, false, true, 0, 0}; // tabs==tabs
  854.         Nlm_ColData* coldata= NULL;
  855.  
  856.         gCursor->watch();
  857.         aFile->CloseFile(); // ShowFile manages this..
  858.         char* shortname= (char*)aFile->GetShortname();
  859.         DWindow* win= new DWindow(0, this, DWindow::document, -1, -1, -10, -10, shortname);
  860.         DTextDocPanel* td= new DTextDocPanel(0, win, 500, 300);
  861.  
  862.         td->SetSlateBorder( false);
  863.         td->SetResize( DView::matchsuper, DView::relsuper);
  864.         //td->SetTabs( gTextTabStops);
  865.         
  866.         const char* fullname= aFile->GetName();
  867. #if 0
  868.         td->ShowFile( (char*)fullname, gTextFont);
  869. #else
  870.         td->ShowFileFancy( (char*)fullname, ¶tabs, coldata, gTextFont, gTextTabStops);
  871. #endif
  872.         
  873.         win->Open();
  874.         td->SizeToSuperview( win, true, false); // this needs to adjust for if view has scrollbar !
  875.         gCursor->arrow();
  876.         }
  877. }
  878.  
  879.  
  880. Boolean    DApplication::ChooseFile(DFile*& openedFile, char* filesuffix, char* acceptableTypeIDs)
  881. {
  882.     DFile* aFile;
  883.     //if (openedFile) delete openedFile; //??
  884.     openedFile= NULL;
  885.     char* name= (char*) gFileManager->GetInputFileName( filesuffix, acceptableTypeIDs); 
  886.     if (name) {
  887.         aFile= new DFile( name, "r");
  888.         if (aFile->Exists()) {
  889.             openedFile= aFile;
  890.             return true;
  891.             }
  892.         else {
  893.             delete aFile;
  894.             return false;
  895.             }
  896.         }
  897.     else
  898.         return false;
  899. }
  900.  
  901.  
  902.  
  903. Boolean DApplication::DoMenuTask(long tasknum, DTask* theTask)
  904. {
  905.     DWindow* win;
  906.     
  907.     switch (tasknum) {
  908.  
  909.         case DAppleMenu::kAboutMenuItem: 
  910.             // ^^this is likely handled by DAppleMenu object
  911.         case kAbout:
  912.             this->DoAboutBox();
  913.             return true;
  914.  
  915.         case kHelp:
  916.             this->DoHelp();
  917.             return true;
  918.             
  919.         case kNew:
  920.             Message(MSG_OK,"DApplication::New not ready.");
  921.             //this->CreateDocument();
  922.             return true;
  923.         
  924.         case kPrintAFile:    
  925.         case kOpenAFile:
  926.             if (theTask)  
  927.                 this->OpenDocument( (char*)theTask->fExtra);
  928.             return true;
  929.             
  930.         case kOpen:
  931.             {
  932.             DFile* aFile = NULL;
  933.             if (this->ChooseFile( aFile, fFileSuffix, fAcceptableFileTypes)) 
  934.                 this->OpenDocument( aFile);
  935.             }
  936.             return true;
  937.             
  938.         case kClose: 
  939.             win= gWindowManager->CurrentWindow();
  940.             if (win) win->CloseAndFree(); // test win for doc needing saving ??
  941.             return true;
  942.                             
  943.         case kSave:
  944.         case kSaveAs:
  945.         case kSaveACopy:
  946.             win= gWindowManager->CurrentWindow();
  947.             if (win && win->fSaveHandler) {
  948.                 const char* name;
  949.                 char  namestore[256], *defname = NULL;
  950.                 Boolean changewinname= false;
  951.                 
  952.                 if (tasknum == kSave)
  953.                     defname= win->GetFilename(namestore,sizeof(namestore));
  954.                 if (!defname) 
  955.                     defname= win->GetTitle(namestore,sizeof(namestore));
  956.                 if (!defname || !*defname || StrCmp(defname,DFileManager::kUntitled)==0) 
  957.                     tasknum= kSaveAs;  
  958.                 if (tasknum == kSave)
  959.                     name= defname;
  960.                 else {
  961.                     name= gFileManager->GetOutputFileName(defname);
  962.                     changewinname= (tasknum == kSaveAs);
  963.                     }
  964.                 if (name && *name) {
  965.                     DFile* myFile = new DFile(name, "w");
  966.                     if (myFile) {
  967.                         myFile->OpenFile();
  968.                         win->SaveDoc(myFile); 
  969.                         if (changewinname) {
  970.                           win->SetFilename((char*) name);
  971.                           win->SetTitle((char*)DFileManager::FilenameFromPath(name));
  972.                           }
  973.                         myFile->CloseFile();
  974.                         delete myFile;
  975.                         }
  976.                     }
  977.                 }
  978.             else 
  979.                 Message(MSG_OK,"DApplication::Save not ready.");
  980.             return true;
  981.  
  982.         case kFindAgain:
  983.             win= gWindowManager->CurrentWindow();
  984.             if (win && win->fFindDlog) 
  985.                 win->fFindDlog->FindAgain(); 
  986.             else
  987.                 Message(MSG_OK,"DApplication::FindAgain not available.");
  988.             return true;
  989.             
  990.         case kFind:
  991.             win= gWindowManager->CurrentWindow();
  992.             if (win && win->fFindDlog) {
  993.                 if ( win->fFindDlog->PoseModally() ) ;
  994.                 }
  995.             else
  996.                 Message(MSG_OK,"DApplication::Find not available.");
  997.             return true;
  998.             
  999.         case kPrint:
  1000.             win= gWindowManager->CurrentWindow();
  1001.             if (win && win->fPrintHandler) 
  1002.                 win->PrintDoc();
  1003.             else
  1004.                 Message(MSG_OK,"DApplication::Print not ready.");
  1005.             return true;
  1006.  
  1007.         case kQuit:
  1008.             this->Quit(); // this should be a task added to end of task queue...??
  1009.             return true;
  1010.             
  1011.         case kPrevWindow:
  1012.             gWindowManager->BringToFront();
  1013.             return true;
  1014.         case kNextWindow:
  1015.             gWindowManager->SendToBack();
  1016.             return true;
  1017.             
  1018.         case kChooseWindow:
  1019. #ifndef BOBS_WIN_MAC                        
  1020.           {
  1021.             DWindowChoiceDialog* dlg= new DWindowChoiceDialog();
  1022.             if ( dlg->PoseModally() ) {
  1023.                 DWindow* win = dlg->Result();
  1024.                 if (win && win != dlg) win->Select();
  1025.                 }
  1026.             delete dlg;
  1027.             }
  1028. #else
  1029. #endif
  1030.             return true;
  1031.  
  1032.         case kUndo:
  1033.             if (gLastCommand) gLastCommand->UndoRedo();
  1034.             return true;
  1035.  
  1036.         case kDeleteDeadWindow:
  1037.             {
  1038.             DView* windowCarcass= (DView*) theTask->fExtra;
  1039.             if (windowCarcass) delete windowCarcass;
  1040.             }
  1041.             return true;
  1042.  
  1043.         default: 
  1044.             return DTaskMaster::DoMenuTask(tasknum, theTask);
  1045.         }
  1046. }
  1047.  
  1048.  
  1049.  
  1050. Boolean DApplication::IsMyAction(DTaskMaster* action)
  1051. {
  1052.     switch(action->Id()) {
  1053.  
  1054.         case DAppleMenu::kAboutMenuItem:
  1055.         case kAbout:
  1056.         case kHelp:
  1057.         case kNew:
  1058.         case kOpen:
  1059.         case kClose:
  1060.         case kSaveAs:
  1061.         case kSaveACopy:
  1062.         case kSave:
  1063.         case kPrint:
  1064.         case kQuit:
  1065.         case kPrevWindow:
  1066.         case kNextWindow:
  1067.         case kChooseWindow:
  1068.         case kFind:
  1069.         case kFindAgain:
  1070.         case kUndo:
  1071.             return DoMenuTask(action->Id(), NULL);
  1072.  
  1073.         case kCut:
  1074.         case kCopy:
  1075.         case kPaste:
  1076.         case kClear:
  1077.         case kSelectAll:
  1078.             {
  1079.                     // looks like Vibrant doesn't currently support a system clipboard for
  1080.                     // copy/paste of text (& other objects) between applications...
  1081.             static Boolean inrecurse = false;
  1082.             DWindow* win = gWindowManager->CurrentWindow();
  1083.             DDialogText* dtext= gWindowManager->CurrentDialogText();
  1084.             if (inrecurse) return true;
  1085.             inrecurse= true;
  1086.             if (dtext && win && win->HasEditText()) {
  1087.                 if (win != dtext->GetWindow()) dtext = win->fEditText;
  1088.                     // ^^ if this is true, we can't tell which of multiple texts may be
  1089.                     // the intended target ... CurrentDialogText() is supposed to track user text.
  1090.                 if (dtext->IsMyAction(action))  goto doneEditCmd;
  1091.                 }
  1092.             if (win && win->IsMyAction(action)) goto doneEditCmd;
  1093.             Message(MSG_OK,"Application::Edits not ready.");
  1094.     doneEditCmd:
  1095.             inrecurse= false;
  1096.             return true;
  1097.             }
  1098.             
  1099.         case kShowClipboard:
  1100.             gClipboardMgr->DoMenuTask( action->Id(), NULL);
  1101.             return true;
  1102.             
  1103.         case cOKAY:
  1104.         case cCANC:
  1105.             {
  1106.             DButton* but= (DButton*) action;
  1107.             DWindow* win;
  1108.             if ( but && ((win= but->GetWindow()) != NULL) ) {
  1109.                 if (action->Id() == cOKAY) {
  1110.                     // do Okay close handling...
  1111.                     }
  1112.                 win->CloseAndFree();
  1113.                 }
  1114.             }
  1115.             return true;
  1116.  
  1117.         default:
  1118.             return DTaskMaster::IsMyAction(action);
  1119.         }
  1120. }
  1121.  
  1122. DMenu* DApplication::NewMenu(long id, char* title)
  1123. {
  1124.     Nlm_WindoW nwind = (fAppWindow) ? (Nlm_WindoW)fAppWindow->GetNlmObject() : NULL;
  1125.     return new DPulldownMenu( id, this, nwind, title);
  1126. }
  1127.  
  1128.  
  1129. extern "C" void Nlm_SetupMenuBar();
  1130.  
  1131. void    DApplication::SetUpMenus(void)
  1132. {
  1133.     DMenu* aMenu = NULL;
  1134.     this->SetUpMenu(cFileMenu, aMenu);
  1135.     aMenu= NULL;
  1136.     this->SetUpMenu(cEditMenu, aMenu);
  1137.     aMenu= NULL;
  1138.     this->SetUpMenu(cWindowMenu, aMenu);
  1139.     this->SetUpMenu( 0, aMenu);
  1140. }
  1141.  
  1142. void DApplication::SetUpMenu(short menuId, DMenu*& aMenu) 
  1143. {
  1144.     // ?? either change menu objects to local/nonpointer, 
  1145.     // or suicide() them to remove all but DViewCentral owner
  1146.     
  1147.     if (menuId == cFileMenu) {
  1148. #ifdef WIN_MAC
  1149.         DAppleMenu* appleMenu = new DAppleMenu(this,fAboutLine);
  1150. #endif
  1151.         if (!aMenu) aMenu = this->NewMenu( cFileMenu, "File");
  1152. #ifndef WIN_MAC
  1153.         aMenu->AddItem(kAbout, fAboutLine);
  1154.         aMenu->AddSeparator();
  1155. #endif
  1156.         aMenu->AddItem(kNew,"New/N",false, true);
  1157.         aMenu->AddItem(kOpen,"Open/O",false, true);
  1158.         aMenu->AddSeparator();
  1159.         aMenu->AddItem(kClose,"Close/W",false, true);
  1160.         aMenu->AddItem(kSave,"Save/S",false, true);
  1161.         aMenu->AddItem(kSaveAs,"Save As...",false, true);
  1162.         aMenu->AddSeparator();
  1163.         aMenu->AddItem(kPrint,"Print",false, true);
  1164.         aMenu->AddItem(kHelp,"Help/H",false, true);
  1165.         aMenu->AddSeparator();
  1166.         aMenu->AddItem(kQuit,"Quit/Q",false, true);
  1167.         }
  1168.     
  1169.     else if (menuId == cEditMenu) {
  1170.         if (!aMenu) aMenu = this->NewMenu(cEditMenu, "Edit");
  1171.         aMenu->AddItem(kUndo,"Undo/Z",false, true);
  1172.         gViewCentral->DisableView(kUndo);  // don't know undo yet... :-(ouch)
  1173.         aMenu->AddSeparator();
  1174.         aMenu->AddItem(kCut,"Cut/X",false, true);
  1175.         aMenu->AddItem(kCopy,"Copy/C",false, true);
  1176.         aMenu->AddItem(kPaste,"Paste/V",false, true);
  1177.         aMenu->AddItem(kClear,"Clear",false, true);
  1178.         aMenu->AddItem(kSelectAll,"Select All/A",false, true);    
  1179.         aMenu->AddItem(kShowClipboard,"Show clipboard",false, true);
  1180.         gViewCentral->DisableView(DApplication::kShowClipboard);
  1181.         }
  1182.         
  1183.     else if (menuId == cWindowMenu) {
  1184.         if (!aMenu) aMenu= this->NewMenu(cWindowMenu, "Windows");
  1185.         aMenu->AddItem(kPrevWindow,"Prev/-",false, true); // == bring last win to front
  1186.         aMenu->AddItem(kNextWindow,"Next/+",false, true); // == send top win to last
  1187.         aMenu->AddItem(kChooseWindow,"Select...");  
  1188.         //aMenu->AddSeparator();
  1189.         //this->AddWindowListToMenu(menuId, aMenu); //gWindowManager->GetWindowList();
  1190.         }
  1191.         
  1192.     else if (menuId == 0) {
  1193.         Nlm_SetupMenuBar();
  1194.         }
  1195.  
  1196. }
  1197.  
  1198.  
  1199.  
  1200. #if NOT_READY
  1201.     
  1202. void DApplication::SetWindowMenu(Boolean activate)
  1203. {                  
  1204. #ifndef BOBS_WIN_MAC                        
  1205.                         // THIS IS NO GOOD ON XWIN, and on MSWIN
  1206.                         // Vibrant currently has no way of removing single menu items
  1207.                         // except for Mac.  Only option for others seems to be removal
  1208.                         // of entire (sub) menu, with no way to replace w/ a new menu
  1209.                         // in *same* position !!!
  1210. #else                        
  1211.    if (fWindowChoiceMenu) {
  1212.          short item= kViewDefault;
  1213.          fWindowChoiceMenu->Reset();  
  1214.          fWindowChoiceMenu->AddItem( item, "default");
  1215.          DList* wins= gWindowManager->GetWindowList();
  1216.          if (activate && wins) {
  1217.             long i, n= wins->GetSize();
  1218.             for (i= 0; i<n; i++) {
  1219.                 char *cp, title[256];
  1220.                 item++;
  1221.                 DWindow* win= (DWindow*) fList->At(i);
  1222.                 win->GetTitle(title,256);
  1223.                 cp= title; 
  1224.                 //while (cp= strchr(cp, '/')) *cp= '_';
  1225.                 fViewChoiceMenu->AddItem( item, smenu);
  1226.                 }
  1227.              }
  1228.      }
  1229. #endif
  1230. }
  1231.  
  1232. #endif
  1233.  
  1234.  
  1235.  
  1236.      
  1237. void DApplication::DoHelp()
  1238. {
  1239.     char filename[512];
  1240.     DFile* afile = new DFile();
  1241.     char* suf;
  1242.     
  1243.     char* apppath = (char*) gFileManager->GetProgramPath();  
  1244.     apppath= (char*) gFileManager->PathOnlyFromPath( apppath);
  1245.     apppath= (char*)gFileManager->BuildPath( apppath, kHelpfolder, (char*)Shortname());
  1246.     afile->Initialize(apppath,"r");
  1247.     if (!afile->Exists()) {
  1248.         StrNCpy(filename, (char*)Shortname(),490);
  1249.         StrCat(filename,".help");
  1250.         afile->Initialize(filename,"r");
  1251.         if (!afile->Exists()) {
  1252.             StrNCpy(filename, (char*)Pathname(),490);
  1253.             suf= (char*)gFileManager->FileSuffix(filename); if (suf) *suf= 0;
  1254.             StrCat(filename,".help");
  1255.             afile->Initialize(filename,"r");
  1256.             }
  1257.         }
  1258.     OpenHelp( afile);
  1259.     delete afile;
  1260. }
  1261.  
  1262.  
  1263.  
  1264. void DApplication::OpenHelp(const char* helpname)
  1265. {
  1266.     char* apppath = (char*) gFileManager->GetProgramPath();  
  1267.     apppath= (char*) gFileManager->PathOnlyFromPath( apppath);
  1268.     const char*    pathname= gFileManager->BuildPath( apppath, kHelpfolder, helpname);
  1269.     DFile* afile = new DFile(pathname,"r");
  1270.     OpenHelp(afile);
  1271.     delete afile;
  1272. }
  1273.  
  1274.  
  1275. void DApplication::OpenHelp(DFile* aFile)
  1276. {
  1277. #if 1
  1278.     if (!aFile || !aFile->Exists()) {
  1279.         const char * name;
  1280.         if (aFile) name= aFile->GetName(); else name= "noname";
  1281.         Message(MSG_OK,"Can't find help file '%s'",name);
  1282.         return;
  1283.         }
  1284.     this->OpenDocument( aFile); 
  1285. #else
  1286.     Nlm_ParData  paratabs = {false, false, false, false, true, 0, 0}; // tabs==tabs
  1287.     Nlm_ColData* coldata= NULL;
  1288.         
  1289.     if (!aFile->Exists()) {
  1290.         Message(MSG_OK,"Can't find help file '%s'",aFile->GetName());
  1291.         return;
  1292.         }
  1293.         
  1294.     gCursor->watch();
  1295.     aFile->CloseFile(); // make sure closed so ShowFile can open !?
  1296.     DWindow* win= new DWindow(cHelp, this, DWindow::document, -1, -1, -10, -10, 
  1297.                                         (char*) aFile->GetShortname());
  1298.     DTextDocPanel* td= new DTextDocPanel(0, win, 490, 300);
  1299.     td->SetSlateBorder( false);
  1300.     td->SetResize( DView::matchsuper, DView::relsuper);
  1301. #if 0
  1302.     td->ShowFile( (char*)aFile->GetName(), gTextFont);
  1303. #else
  1304.     td->ShowFileFancy( (char*)aFile->GetName(), ¶tabs, coldata, gTextFont, gTextTabStops);
  1305. #endif
  1306.     win->Open();
  1307.     td->SizeToSuperview( win, true, false);  
  1308.     gCursor->arrow();
  1309. #endif
  1310. }
  1311.  
  1312.  
  1313. void DApplication::DoAboutBox(void)
  1314. {
  1315.     DAboutBoxWindow* about = new DAboutBoxWindow; // make instance & it handles rest
  1316. }
  1317.  
  1318.     
  1319.  
  1320.  
  1321. void DApplication::UpdateMenus( void)
  1322. {
  1323.         // Is the frontmost window modal?
  1324.     
  1325.     gViewCentral->EnableView(DApplication::kQuit);
  1326.  
  1327.     //if (gInBackground) 
  1328.     {
  1329.         gViewCentral->EnableView(DApplication::kClose);
  1330.         //gViewCentral->EnableView(DApplication::kUndo);
  1331.         gViewCentral->EnableView(DApplication::kCut);
  1332.         gViewCentral->EnableView(DApplication::kCopy);
  1333.         gViewCentral->EnableView(DApplication::kPaste);
  1334.         gViewCentral->EnableView(DApplication::kClear);
  1335.     } 
  1336.  
  1337.     //if (!isModalWindow) 
  1338.     {
  1339.         gViewCentral->EnableView(DApplication::kNew);
  1340.         gViewCentral->EnableView(DApplication::kOpen);
  1341.     }
  1342.  
  1343.     gViewCentral->EnableView(DApplication::kPrevWindow);
  1344.     gViewCentral->EnableView(DApplication::kNextWindow);
  1345.     
  1346.     //Str63    undoStr;
  1347.     //GetIndString(undoStr, STRcommon, strUNDO);
  1348.     //gViewCentral->SetMenuText( DApplication::kUndo, undoStr);
  1349. }
  1350.  
  1351.  
  1352.  
  1353.  
  1354.